package com.guchenbo.scala

import com.guchenbo.scala.MyDef.int2MyInt

//import com.guchenbo.scala.MyDef._

/**
 * @author guchenbo
 * @date 2022/3/19
 */
object ImplicitDemo {


  def main(args: Array[String]): Unit = {

    val imp = new Imp(12)
    val arr = Array(1, 2, 3)
    println(arr.length)
    //    imp类型没有length方法，编译器发现上面有隐式转换，就把Imp转换为Array，就有length方法类
    println(imp.length)
    println(Imp)
    println(Imp(10).length)
    //    有隐式转换，把Int转换为RichInt，就有max方法了
    println(12.max(14))

    //    有隐式转换，把Int转换为MyInt，就有myMax方法了
    println(12.myMax(11))

    //    隐式参数

    // 使用默认参数，可以不传值
    def m1(string: String = "apple"): Unit = {
      println(string)
    }

    implicit val str = "brana"
    implicit val i = 12

    // 用隐式参数，也可以不传值，会从当前作用域中查找相同类型的变量
    def m2(implicit string: String): Unit = {
      println(string)
    }

    // 查找相同类型的变量，隐式参数可以有多个
    def m22(implicit string: String, int: Int): Unit = {
      println(string, int)
    }

    def m3(): Unit = {
      //      使用implicitly查找隐式参数
      println(implicitly[String], implicitly[Int])
    }

    m1()
    // 查找相同类型的变量
    m2
    m22
    m3()

    //    隐式类
    //    自动转换，把List转换为MyList
    implicit class MyList[T](val list: List[T]) {
      def myLength: Int = {
        println("in my")
        list.length
      }
    }
    val li = List(1, 2)
    println(li.myLength)
  }
}


class MyInt(val value: Int) {

  def myMax(b: Int): Int = {
    if (value > b) value else b
  }

}

